package com.PuzGame.combinenumbers;

public class RationalNumber {
	
	 private long numerator, denominator;

	   //-----------------------------------------------------------------
	   //  Constructor: Sets up the rational number by ensuring a nonzero
	   //  denominator and making only the numerator signed.
	   //-----------------------------------------------------------------
	   public RationalNumber (long numer, long denom)
	   {
	      if (denom == 0)
	         denom = 1;

	      // Make the numerator "store" the sign
	      if (denom < 0)
	      {
	         numer = numer * -1;
	         denom = denom * -1;
	      }

	      numerator = numer;
	      denominator = denom;

	      reduce();
	   }

	   //-----------------------------------------------------------------
	   //  Returns the numerator of this rational number.
	   //-----------------------------------------------------------------
	   public long getNumerator ()
	   {
	      return numerator;
	   }

	   //-----------------------------------------------------------------
	   //  Returns the denominator of this rational number.
	   //-----------------------------------------------------------------
	   public long getDenominator ()
	   {
	      return denominator;
	   }

	   //-----------------------------------------------------------------
	   //  Returns the reciprocal of this rational number.
	   //-----------------------------------------------------------------
	   public RationalNumber reciprocal ()
	   {
	      return new RationalNumber (denominator, numerator);
	   }

	   //-----------------------------------------------------------------
	   //  Adds this rational number to the one passed as a parameter.
	   //  A common denominator is found by multiplying the individual
	   //  denominators.
	   //-----------------------------------------------------------------
	   public RationalNumber add (RationalNumber op2)
	   {
		   long commonDenominator = denominator * op2.getDenominator();
		   long numerator1 = numerator * op2.getDenominator();
		   long numerator2 = op2.getNumerator() * denominator;
		   long sum = numerator1 + numerator2;

	      return new RationalNumber (sum, commonDenominator);
	   }

	   //-----------------------------------------------------------------
	   //  Subtracts the rational number passed as a parameter from this
	   //  rational number.
	   //-----------------------------------------------------------------
	   public RationalNumber subtract (RationalNumber op2)
	   {
		   long commonDenominator = denominator * op2.getDenominator();
		   long numerator1 = numerator * op2.getDenominator();
		   long numerator2 = op2.getNumerator() * denominator;
		   long difference = numerator1 - numerator2;

	      return new RationalNumber (difference, commonDenominator);
	   }

	   //-----------------------------------------------------------------
	   //  Multiplies this rational number by the one passed as a
	   //  parameter.
	   //-----------------------------------------------------------------
	   public RationalNumber multiply (RationalNumber op2)
	   {
		   long numer = numerator * op2.getNumerator();
		   long denom = denominator * op2.getDenominator();

	      return new RationalNumber (numer, denom);
	   }

	   //-----------------------------------------------------------------
	   //  Divides this rational number by the one passed as a parameter
	   //  by multiplying by the reciprocal of the second rational.
	   //-----------------------------------------------------------------
	   public RationalNumber divide (RationalNumber op2)
	   {
	      return multiply (op2.reciprocal());
	   }

	   //-----------------------------------------------------------------
	   //  Determines if this rational number is equal to the one passed
	   //  as a parameter.  Assumes they are both reduced.
	   //-----------------------------------------------------------------
	   public boolean equals (RationalNumber op2)
	   {
	      return ( numerator == op2.getNumerator() &&
	               denominator == op2.getDenominator() );
	   }

	   //-----------------------------------------------------------------
	   //  Returns this rational number as a string.
	   //-----------------------------------------------------------------
	   public String toString ()
	   {
	      String result;

	      if (numerator == 0)
	         result = "0";
	      else
	         if (denominator == 1)
	            result = numerator + "";
	         else
	            result = numerator + "/" + denominator;
	    
	      return result;
	   }

	   //-----------------------------------------------------------------
	   //  Reduces this rational number by dividing both the numerator
	   //  and the denominator by their greatest common divisor.
	   //-----------------------------------------------------------------
	   private void reduce ()
	   {
	      if (numerator != 0)
	      {
	    	  long common = gcd (Math.abs(numerator), denominator);

	         numerator = numerator / common;
	         denominator = denominator / common;
	      }
	   }

	   //-----------------------------------------------------------------
	   //  Computes and returns the greatest common divisor of the two
	   //  positive parameters. Uses Euclid's algorithm.
	   //-----------------------------------------------------------------
	   private long gcd (long num1, long num2)
	   {
	      while (num1 != num2)
	         if (num1 > num2)
	            num1 = num1 - num2;
	         else
	            num2 = num2 - num1;

	      return num1;
	   }

	public boolean iSNegative()
	{
		return numerator * denominator < 0;
	}

	public boolean IsNatural() {
		
		return denominator == 1;
	}

}
